Software engineering is the application of a systematic and disciplined approach to the development and maintenance of computer programs, applications, and other software systems. Due to the increasing computerization of the world's economy, the need for effective software engineering methodologies is more important than ever.
The traditional software development process involves a number of phases. First, the requirements of the program are specified, typically in the form of a written specification document based on customer needs. Then, a software developer writes source code to implement the requirements, for example, by designing data structures and coding the system logic. Finally, the software developer undergoes an extensive testing and debugging phase in which mistakes and ambiguities in the requirements are identified and errors in the software code are fixed. Having to refine the system requirements is one of the most serious problems that might occur, because any modification to the requirements necessitates a redevelopment of the source code, starting the process all over again. Thus, the testing and debugging phase is the longest phase in the software engineering process and the most difficult to estimate completion times.
For the past forty years, there have been many attempts to improve isolated portions of the software engineering process. For example, the creation of first higher-level languages such as FORTRAN and then of structured programming languages such as ALGOL has helped ease the burden of implementing the system logic. As another example, the introduction of object-oriented methodologies has helped in the design and implementation of data structures. These improvements in the software engineering process have lessened the mismatch between the problem space, which is the Conceptual Model for the application, and the solution space, which is the actual software code. Nevertheless, some mismatch between the problem space and the solution space remains, which gives rise to an opportunity for programming errors. Because of the programming errors, it is necessary to undergo an extensive testing and debugging phase to isolate and fix the software faults.
Lately, there has been some interest in the use of “requirements analysis” and Computer Aided Software Engineering (CASE) to facilitate the first phase of the software engineering process, which is the identification and specification of the requirements. In particular, these approaches attempt to allow for software engineers to formally specify the requirements and build a prototype to validate and test the requirements. After the requirements are tested, the prototype is discarded and the software engineer develops the complete software application based on the requirements.
One example is known as “OMTROLL”, whose objective is to assist software designers by means of an Object Modeling Technique (OMT)-compliant graphical notation to build the formal specification of the system. This specification is based on the TROLL specification language and has to be refined to a complete system specification. In addition, OMTROLL has a CASE support called TrollWorkbench, which provides a prototyping function by generating an independently executable prototype from a graphical conceptual specification. The prototype generated is a C++ program that includes the static/dynamic aspects of the system and uses an Ingress database as a repository of the specification.
OBLOG is another object-oriented approach for software development that falls within the scope of the European ESPRIT project IS-CORE (Information Systems-Correctness and Reusability). The OBLOG semantics is formalized in the context of the theory of categories. OBLOG also employs a CASE tool for introducing specifications and enables a developer to build a prototype by supplying rewrite rules to convert the specifications into code for the prototype. The rewrite rules must be written using a specific language provided by OBLOG.
Another approach that focuses more on levels of formalism is the Object System Analysis model (OSA). The aim of OSA is to develop a method that enables system designers to work with different levels of formalism, ranging from informal to mathematically rigorous. In this context, this kind of tunable formalism encourages both theoreticians and practitioners to work with the same model allowing them to explore the difficulties encountered in making model and languages equivalent and resolve these difficulties in the context of OSA for a particular language. OSA also has a CASE support tool called IPOST, which can generate a prototype from an OSA model to validate the requirements.
A different approach has been proposed by SOFL (Structured-Object-based-Formal Language), whose aim is to address the integration of formal methods into established industrial software processes using an integration of formal methods, structured analysis and specifications, and an object-based method. SOFL facilitates the transformation from requirements specifications in a structured style to a design in an object-based style and facilitates the transformation from designs to programs in the appropriate style. In accordance with the previous arguments, the SOFL proposal attempts to overcome the fact that formal methods have not been largely used in industry, by finding mechanisms to link object-oriented methodology and structured techniques with formal methods, e.g. VDM (Vienna Development Method) style semantics for its specification modules. Combining structured and objected-oriented techniques in a single method, however, makes it difficult to clarify the method semantics; thus, effective tool support is necessary for checking consistency.
Still another approach is known as TRADE (Toolkit for Requirements and Design Engineering), whose conceptual framework distinguishes external system interactions from internal components. TRADE contains techniques from structured and object-oriented specification and design methods. A graphical editor called TCM (Toolkit for Conceptual Modeling) is provided to support the TRADE framework.
Although these approaches are of some help for the first phase, i.e. in refining the requirements before the computer application is coded, they do not address the main source for the lack of productivity during later phases of the software engineering process, namely the programming and testing/debugging phases. For example, once the requirements are identified, the software engineer typically discards the prototype generated by most of these approaches and then designs and implements the requirements in a standard programming language such as C++. The newly developed code, due to the mismatch between the problem space and the solution space, will commonly contain coding errors and will need to be extensively tested and debugged.
Even if the prototype is not discarded and used as skeleton for the final application, the software developer must still develop additional code, especially to implement the user interface and error processing. In this case, there still remains the need for testing and debugging the code the programmer has written. The rule-rewriting approach of OBLOG, moreover, fails to address this need, because the difficulties associated with programming are merely shifted one level back, to the development of the rewriting rules in an unfamiliar, proprietary language.
Other approaches include those of Rational and Sterling, but these are not based on a formal language.
Therefore, there exists a long-felt need for improving the software engineering process, especially for reducing the amount of time spent in the programming and testing phases. In addition, a need exists for a way to reducing programming errors during the course of developing a robust software application. Furthermore, there is also a need for facilitating the maintenance of software applications when their requirements have changed.